/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package logica.validacion;

import java.util.StringTokenizer;
import java.util.regex.Pattern;

/**
 *
 * @author Gonzalo
 */
public class PersonaValidacion extends CapaValidacion {

    /**
     * Determina si el par (tipo, número) de documento es válido.
     *
     * @param tipo (lc/le/dni/pasaporte)
     * @param numero El número de documento
     * @param esObligatorio Obligatoriedad del campo
     * @return true si es válido, false en caso contrario
     */
    public static boolean validarDocumento(String tipo, String numero,
            boolean esObligatorio) {

        String tipoTemp = tipo.toLowerCase();
        Pattern patronPasaporte = Pattern.compile("[A-Za-z0-9]+");

        if ((tipoTemp.equals("dni") || (tipoTemp.equals("lc"))) &&
                (numero.length() == 8 || numero.length() == 7) &&
                CapaValidacion.esTodoNumero(numero)) {
            return true;

        } else if (tipoTemp.equals("le") && numero.length() == 8 &&
                CapaValidacion.esTodoNumero(numero)) {
            return true;

        } else if (tipoTemp.equals("pasaporte u otro") &&
                patronPasaporte.matcher(numero).matches()) {
            return true;

        } else if (!esObligatorio) {
            return tipo.isEmpty() || numero.isEmpty();
        }

        return false;
    }

    /**
     * Determina si el nombre de una persona es válido.
     *
     * @param nombre El nombre de la persona
     * @param esObligatorio Obligatoriedad del campo
     * @return true si es válido, false en caso contrario
     */
    public static boolean validarNombre(String nombre,
            boolean esObligatorio) {
        boolean esValido = true;
        String nombreTemp = nombre.toLowerCase();

        if ((esObligatorio && nombre.isEmpty()) || esCadenaVacia(nombre)) {
            esValido = false;
        }

        //Se separa en palabras si es que existen y se trabaja por cada palabra
        StringTokenizer tokens = new StringTokenizer(nombreTemp);
        while (tokens.hasMoreTokens()) {
            String palabra = tokens.nextToken();

            //La palabra debe tener al menos dos letras
            if (palabra.length() < 2) {
                esValido = false;
            }

            //La palabra no debe contener apostrofos
            if (palabra.indexOf("\'") != -1) {
                esValido = false;
            }

            //La palabra debe ser una cadena alfabetica
            if (!CapaValidacion.esAlfabetico(palabra)) {
                esValido = false;
            }
        }

        return esValido;
    }

    /**
     * Determina si el apellido de una persona es válido.
     *
     * @param apellido El apellido de la persona
     * @param esObligatorio Obligatoriedad del campo
     * @return true si es válido, false en caso contrario
     */
    public static boolean validarApellido(String apellido,
            boolean esObligatorio) {
        boolean esValido = true;
        String apellidoTemp = apellido.toLowerCase();

        if (esObligatorio && apellido.isEmpty() || esCadenaVacia(apellido)) {
            esValido = false;
        }

        //Separamos palabras si es que existen y se trabaja por cada palabra
        StringTokenizer tokens = new StringTokenizer(apellidoTemp);
        while (tokens.hasMoreTokens()) {
            String palabra = tokens.nextToken();

            //Cada palabra debe tener al menos dos letras
            if (palabra.length() < 2) {
                esValido = false;
            }

            //No debe tener ñ y ' al mismo tiempo
            if (palabra.contains("ñ") && palabra.contains("\'")) {
                esValido = false;
            }

            //No debe tener mas de un apostrofo
            if (palabra.indexOf("\'") != palabra.lastIndexOf("\'")) {
                esValido = false;
            }

            //no debe tener apostrofo al principio ni al final
            if ((palabra.indexOf("\'") == 0)
                    || (palabra.indexOf("\'") >= (palabra.length() - 1))) {
                esValido = false;
            }

            //Debe ser una cadena alfabetica
            if (!CapaValidacion.esAlfabetico(palabra)) {
                esValido = false;
            }
        }

        return esValido;
    }

    /**
     * Determina si el teléfono es válido.
     *
     * @param telefono El teléfono
     * @param esObligatorio Obligatoriedad del campo
     * @return true si es válido, false en caso contrario
     */
    public static boolean validarTelefono(String telefono, boolean esObligatorio) {
        boolean esValido = true;
        Pattern patron = Pattern.compile("[0-9]*");

        if (esObligatorio && (telefono.isEmpty() ||
                esCadenaVacia(telefono))) {
            esValido = false;
        }

        //Separamos palabras si es que existen y se trabaja por cada palabra
        StringTokenizer tokens = new StringTokenizer(telefono);
        while (tokens.hasMoreTokens()) {
            String palabra = tokens.nextToken();

            if (!patron.matcher(palabra).matches()) {
               esValido = false;
            }
        }

        return esValido;
    }

    /**
     * Valida el sexo de una persona. No puede existir una persona sin sexo
     * seleccionado.
     *
     * @param seleccionFemenino Indica si esta seleccionado femenino
     * @param seleccionMasculino Indica si esta seleccionado masculino
     * @param esObligatorio Obligatoriedad del campo
     * @return true si es válido, false en caso contrario
     */
    public static boolean validarSexo(boolean seleccionFemenino,
            boolean seleccionMasculino, boolean esObligatorio) {
        if (esObligatorio) {
            return seleccionFemenino || seleccionMasculino;
        }

        return true;
    }
    
}
